// API配置
const API_CONFIG = {
  baseUrl: 'https://api.siliconflow.cn/v1',
  // 在实际使用中，你需要在插件设置中配置API密钥
  apiKey: ''
};

// DOM元素
const elements = {
  inputText: document.getElementById('inputText'),
  customInstruction: document.getElementById('customInstruction'),
  modelSelect: document.getElementById('modelSelect'),
  translateBtn: document.getElementById('translateBtn'),
  summarizeBtn: document.getElementById('summarizeBtn'),
  explainBtn: document.getElementById('explainBtn'),
  customBtn: document.getElementById('customBtn'),
  outputText: document.getElementById('outputText'),
  status: document.getElementById('status'),
  stopBtn: document.getElementById('stopBtn') // 添加中止按钮
};

// 缓存键名
const API_KEY_STORAGE_KEY = 'siliconFlowApiKey';
const MODEL_STORAGE_KEY = 'siliconFlowModel';
const CUSTOM_INSTRUCTION_KEY = 'customInstruction';

// 控制流式请求的控制器
let abortController = null;

// 初始化
document.addEventListener('DOMContentLoaded', async () => {
  // 加载缓存数据
  loadCachedData();
  
  // 绑定事件
  elements.translateBtn.addEventListener('click', processTranslation);
  elements.summarizeBtn.addEventListener('click', () => processText('summarize'));
  elements.explainBtn.addEventListener('click', () => processText('explain'));
  elements.customBtn.addEventListener('click', processCustomInstruction);
  elements.stopBtn.addEventListener('click', stopGeneration); // 绑定中止事件
  
  // 加载保存的模型选择
  loadSavedModel();
  
  // 监听模型选择变化
  elements.modelSelect.addEventListener('change', saveModelSelection);
  
  // 监听自定义指令输入框变化并保存
  elements.customInstruction.addEventListener('blur', saveCustomInstruction);
  
  // 检查是否有保存的API密钥
  const savedApiKey = await getStoredApiKey();
  if (!savedApiKey) {
    alert('请先在扩展选项中设置硅基流动API密钥');
  }
});

// 加载缓存数据
async function loadCachedData() {
  try {
    // 加载自定义指令缓存
    const cachedData = await chrome.storage.local.get([CUSTOM_INSTRUCTION_KEY]);
    if (cachedData[CUSTOM_INSTRUCTION_KEY]) {
      elements.customInstruction.value = cachedData[CUSTOM_INSTRUCTION_KEY];
    }
  } catch (error) {
    console.error('加载缓存数据失败:', error);
  }
}

// 加载保存的模型选择
async function loadSavedModel() {
  try {
    const data = await chrome.storage.local.get(MODEL_STORAGE_KEY);
    if (data[MODEL_STORAGE_KEY]) {
      elements.modelSelect.value = data[MODEL_STORAGE_KEY];
    }
  } catch (error) {
    console.error('加载模型选择失败:', error);
  }
}

// 保存模型选择
async function saveModelSelection() {
  try {
    await chrome.storage.local.set({ [MODEL_STORAGE_KEY]: elements.modelSelect.value });
  } catch (error) {
    console.error('保存模型选择失败:', error);
  }
}

// 保存自定义指令
async function saveCustomInstruction() {
  try {
    const instruction = elements.customInstruction.value.trim();
    if (instruction) {
      await chrome.storage.local.set({ [CUSTOM_INSTRUCTION_KEY]: instruction });
    } else {
      await chrome.storage.local.remove(CUSTOM_INSTRUCTION_KEY);
    }
  } catch (error) {
    console.error('保存自定义指令失败:', error);
  }
}

// 获取存储的API密钥
async function getStoredApiKey() {
  try {
    const data = await chrome.storage.local.get(API_KEY_STORAGE_KEY);
    return data[API_KEY_STORAGE_KEY] || '';
  } catch (error) {
    console.error('获取API密钥失败:', error);
    return '';
  }
}

// 处理翻译（中英互译）
async function processTranslation() {
  const inputText = elements.inputText.value.trim();
  
  if (!inputText) {
    alert('请输入要翻译的文本');
    return;
  }
  
  // 确定翻译方向
  const isChinese = /[\u4e00-\u9fa5]/.test(inputText);
  const targetLanguage = isChinese ? 'English' : 'Chinese';
  
  // 构建提示词
  const prompt = `请将以下文本翻译成${targetLanguage}：\n\n${inputText}`;
  
  // 执行处理
  await processWithPrompt(prompt);
}

// 处理文本（总结/解释）
async function processText(operation) {
  const inputText = elements.inputText.value.trim();
  
  if (!inputText) {
    alert('请输入要处理的文本');
    return;
  }
  
  // 构建提示词
  let prompt = '';
  switch (operation) {
    case 'summarize':
      prompt = `请总结以下文本内容，提取主要观点和要点：\n\n${inputText}`;
      break;
    case 'explain':
      prompt = `请详细解释以下文本内容，使其易于理解：\n\n${inputText}`;
      break;
    default:
      prompt = inputText;
  }
  
  // 执行处理
  await processWithPrompt(prompt);
}

// 处理自定义指令
async function processCustomInstruction() {
  const inputText = elements.inputText.value.trim();
  const customInstruction = elements.customInstruction.value.trim();
  
  if (!inputText) {
    alert('请输入要处理的文本');
    return;
  }
  
  // 构建提示词 - 当自定义指令为空时，直接使用输入文本
  let prompt;
  if (!customInstruction) {
    prompt = inputText;
  } else {
    prompt = `请根据以下要求处理文本：\n\n文本内容：${inputText}\n处理要求：${customInstruction}`;
  }
  
  // 执行处理
  await processWithPrompt(prompt);
}

// 使用指定提示词处理文本
async function processWithPrompt(prompt) {
  const model = elements.modelSelect.value;
  console.log(model, 99999)
  
  // 禁用处理按钮
  setProcessingState(true);
  
  try {
    // 清空输出区域
    elements.outputText.textContent = '';
    
    // 调用流式API
    await callSiliconFlowStreamAPI(prompt, model);
    
    // 更新状态
    elements.status.textContent = '处理完成';
    elements.status.className = 'status completed';
  } catch (error) {
    if (error.name === 'AbortError') {
      elements.status.textContent = '已中止';
      elements.status.className = 'status';
    } else {
      console.error('处理文本时出错:', error);
      elements.outputText.textContent = `错误: ${error.message}`;
      elements.status.textContent = '处理失败';
      elements.status.className = 'status error';
    }
  } finally {
    // 启用处理按钮
    setProcessingState(false);
    // 隐藏中止按钮
    elements.stopBtn.style.display = 'none';
  }
}

// 调用硅基流动流式API
async function callSiliconFlowStreamAPI(prompt, model) {
  const apiKey = await getStoredApiKey();
  
  if (!apiKey) {
    throw new Error('未找到API密钥，请在扩展选项中设置');
  }
  
  // 创建AbortController用于中止请求
  abortController = new AbortController();
  
  const response = await fetch(`${API_CONFIG.baseUrl}/chat/completions`, {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${apiKey}`,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      model: model,
      messages: [{ role: "user", content: prompt }],
      stream: true // 启用流式响应
    }),
    signal: abortController.signal
  });
  
  if (!response.ok) {
    const errorData = await response.json().catch(() => ({}));
    throw new Error(errorData.error?.message || `API请求失败: ${response.status} ${response.statusText}`);
  }
  
  const reader = response.body.getReader();
  const decoder = new TextDecoder('utf-8');
  let buffer = '';
  
  // 显示中止按钮
  elements.stopBtn.style.display = 'block';
  
  try {
    while (true) {
      const { done, value } = await reader.read();
      if (done) break;
      
      buffer += decoder.decode(value, { stream: true });
      
      // 处理接收到的数据块
      const lines = buffer.split('\n');
      buffer = lines.pop(); // 保留不完整的行
      
      for (const line of lines) {
        if (line.startsWith('data: ')) {
          const data = line.slice(6);
          
          if (data === '[DONE]') {
            return; // 流结束
          }
          
          try {
            const parsed = JSON.parse(data);
            const content = parsed.choices?.[0]?.delta?.content;
            if (content) {
              elements.outputText.textContent += content;
              // 自动滚动到底部
              elements.outputText.scrollTop = elements.outputText.scrollHeight;
            }
          } catch (e) {
            // 忽略解析错误
          }
        }
      }
    }
  } finally {
    reader.releaseLock();
  }
}

// 中止生成过程
function stopGeneration() {
  if (abortController) {
    abortController.abort();
  }
}

// 流式显示文本
function streamText(text) {
  let i = 0;
  const speed = 20; // 打字速度（毫秒）
  
  function typeWriter() {
    if (i < text.length) {
      elements.outputText.textContent += text.charAt(i);
      i++;
      setTimeout(typeWriter, speed);
    }
  }
  
  typeWriter();
}

// 设置处理状态
function setProcessingState(processing) {
  elements.translateBtn.disabled = processing;
  elements.summarizeBtn.disabled = processing;
  elements.explainBtn.disabled = processing;
  elements.customBtn.disabled = processing;
  
  if (processing) {
    elements.status.textContent = '处理中...';
    elements.status.className = 'status processing';
  }
}